After upgrade to version 6 some issue have been identified with compilation of generated code.
When a projection depends on events from different levels of the same inheritance chain, the sorting of methods performed during code generation has been found to be non-deterministic.

Example:

//Events
class BaseEvent {}
class DerivedEventA: BaseEvent {}
class DerivedEventB: BaseEvent {}

//Projection
class Aggregate{
   void Apply(DerivedEventA @event):
   void Apply(DerivedEventB @event):
   void Apply(BaseEvent @event):
}

Will sometimes throw a Unreachable code detected error during compilation of generated code, due to having BaseEvent appearing in switch case order before any of the derived events.

Further investigation has shown that root cause of the issue may reside in EventTypeComparer implementation.
At first glance it looks fine, although the resolution of comparison isn't granular enough, hence when being processed for sorting through .Net internals (depending on API flavour used, may be a QuickSort or Heap+Introspective sort), and optimizations are applied in regards divide and conquer nature of algorithms, having assumptions taken based on partitions and equality (as per result of comparer), which in turn results in some entries never being compared, since all the items in the partition being processed having been reported to be equal by the comparer (comparer returns 0).

Relates to #2749.